home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 7: Sunsite / Linux Cubed Series 7 - Sunsite Vol 1.iso / system / mail / sigrot_v.0 / sigrot_v1.0.tar / sigrot_v1.0 / sigrot.c < prev    next >
C/C++ Source or Header  |  1995-11-18  |  9KB  |  286 lines
  1. /*
  2.  * sigrot.c
  3.  * Written by Christoher Morrone <cmorrone@udel.edu>
  4.  */
  5.  
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include <string.h>
  9. #include <sys/stat.h>
  10. #include <fcntl.h>
  11. #include <unistd.h>
  12.  
  13. /**************************************************************************
  14.  *  The following defines set the standard locations of sigrot's dir and 
  15.  *  files relaive to the $HOME dir.  Edit as desired.
  16.  *
  17.  *  DEST is the file in each user's home dir that is read by mail, news, 
  18.  *      etc. programs that sigrot will write to. (usually .signature)
  19.  *  SOURCE_DIR is the dir in the user's home dir which will contain
  20.  *      sigrot's SOURCE, NEXT, PREFIX and SUFFIX files.
  21.  *  SOURCE is the archive file in the SOURCE_DIR that will contain the list
  22.  *      of signatures.
  23.  *  NEXT is a file in the SOURCE_DIR which contains an integer which tells
  24.  *      sigrot which signature should be read from the archive file next.
  25.  *  PREFIX is a file which contains standard signature information that 
  26.  *      should appear at the top of every .signatur.
  27.  *  SUFFIX is a file which contains standard signature information that
  28.  *      should appear at the bottom of every .signatur.
  29.  **************************************************************************/
  30.  
  31. #define DEST        ".signature"
  32. #define SOURCE_DIR    ".sigrot"
  33. #define    SOURCE        "sig_archive"
  34. #define NEXT        "next"
  35. #define PREFIX        "prefix"
  36. #define SUFFIX        "suffix"
  37.  
  38. /******************************* STOP *************************************
  39.  * It should not be necesarry to edit anything below this line.           
  40.  **************************************************************************/
  41.  
  42. int exists (char *);
  43. void write_next(int);
  44. int get_next();
  45. void find_next_entry(int *,FILE *);
  46. void write_sig(FILE *);
  47. void copy_file(char *,FILE *);
  48.  
  49. char Dest[1024], 
  50.      Source_Dir[1024],
  51.      Source[1024], 
  52.      Next[1024], 
  53.      Prefix[1024], 
  54.      Suffix[1024],
  55.      buffer[1024];
  56.  
  57. int main(int argc, char *argv[])
  58. {
  59.   FILE *inFile,*outFile;
  60.   int next,test=0;
  61.  
  62.   /* Set the full path names */
  63.   sprintf(Dest, "%s/%s", getenv("HOME"), DEST);
  64.   sprintf(Source_Dir, "%s/%s", getenv("HOME"), SOURCE_DIR);
  65.   sprintf(Source, "%s/%s", Source_Dir, SOURCE);
  66.   sprintf(Next, "%s/%s", Source_Dir, NEXT);
  67.   sprintf(Prefix, "%s/%s", Source_Dir, PREFIX);
  68.   sprintf(Suffix, "%s/%s", Source_Dir, SUFFIX);
  69.  
  70.   /* Check for sigrot's dir.  Create if it doesn't exist */
  71.   if ((exists(Source_Dir))==0) test=mkdir(Source_Dir,0700);
  72.   if (test!=0) 
  73.     printf("ERROR: Couldn't create dir \"%s\".\n", Source_Dir);
  74.  
  75.   /* If there are no command line parameters, proceed with normal 
  76.      operation. */
  77.   if (argc==1) { 
  78.     next=get_next(); /* number of the next archive entry to read */
  79.     inFile=fopen(Source,"r");
  80.     if (inFile==NULL)
  81.       fprintf(stderr,"ERROR: Couldn't open \"%s\".\n", Source);
  82.     else {
  83.       find_next_entry(&next,inFile); /* Move file pointer to the 
  84.                                         beginning of the next entry */
  85.       write_sig(inFile);
  86.       fclose(inFile);
  87.       write_next(next); /* Write the number of the entry to be read on the 
  88.                next call to sigrot */
  89.     }
  90.   }
  91.   else {
  92.   /* The following case statements handle command line parameters. */
  93.     switch(argc) {
  94.       case 2: if ((!strcmp(argv[1], "-r")) || 
  95.                   (!strcmp(argv[1], "-on"))) {
  96.                 sprintf(buffer, "%s.bak", Source);
  97.                 outFile=fopen(Source,"w");
  98.                 copy_file(buffer, outFile);
  99.                 fclose(outFile);
  100.                 printf("Old signature archive restored.\n");
  101.               }
  102.           if (!strcmp(argv[1], "-off")) {
  103.                 sprintf(buffer, "%s.bak", Source);
  104.                 outFile=fopen(buffer,"w");
  105.                 copy_file(Source, outFile);
  106.                 fclose(outFile);
  107.             outFile=fopen(Source,"w");
  108.             fclose(outFile);
  109.                 write_next(0);
  110.                 printf("Signatures off.\n");
  111.            }
  112.               break;
  113.       case 3: if (!strcmp(argv[1], "-w")) {
  114.                 sprintf(buffer, "%s.bak", Source);
  115.                 outFile=fopen(buffer,"w");
  116.                 copy_file(Source, outFile);
  117.                 fclose(outFile);
  118.                 outFile=fopen(Source,"w");
  119.                 copy_file(argv[2], outFile);
  120.                 fclose(outFile);
  121.         printf("\"%s\" copied over signature archive.\n", argv[2]);
  122.         printf("Type \"sigrot -r\" to restore the previous archive.\n");
  123.               }
  124.               if (!strcmp(argv[1], "-a")) {
  125.                 sprintf(buffer, "%s.bak", Source);
  126.                 outFile=fopen(buffer,"w");
  127.                 copy_file(Source, outFile);
  128.                 fclose(outFile);
  129.         outFile=fopen(Source,"a");
  130.         fprintf(outFile, "\n");
  131.         copy_file(argv[2], outFile);
  132.         fclose(outFile);
  133.                 printf("\"%s\" appended to signature archive.\n", argv[2]);
  134.                 printf("Type \"sigrot -r\" to restore the previous archive.\n");
  135.           }
  136.           break;
  137.       default: printf("Too many arguments.\n");
  138.     }
  139.   }
  140.   return 0;
  141. }
  142.  
  143. /*******************************************************************
  144.  * exists
  145.  *
  146.  * Return non-zero if directory exists and path components up to at
  147.  * are accessable, 0 if not.
  148.  *******************************************************************/
  149. int exists (char *directory) 
  150. {
  151.   struct stat buf;
  152.   return (!stat (directory, &buf) && S_ISDIR(buf.st_mode));
  153. }
  154.  
  155. /*******************************************************************
  156.  * get_next
  157.  *
  158.  * Access file named in the "#define NEXT" line.
  159.  * Read in interger and return it.
  160.  * If file doesn't exist, return 1.
  161.  *******************************************************************/
  162. int get_next()
  163. {
  164.   FILE *inFile;
  165.   int next;
  166.  
  167.   inFile=fopen(Next,"r");
  168.   if (inFile==NULL)
  169.     next=1;
  170.   else
  171.     fscanf(inFile,"%d",&next);
  172.   fclose(inFile);
  173.   return next;
  174. }
  175.  
  176. /*******************************************************************
  177.  * write_next
  178.  *
  179.  * Increments the value of the current archive entry, and writes it
  180.  * to the file named in the "#define NEXT" line.
  181.  *******************************************************************/
  182. void write_next(int next) {
  183.   FILE *outFile;
  184.  
  185.   outFile=fopen(Next,"w");
  186.   if (outFile==NULL)
  187.     fprintf(stderr,"ERROR: Couldn't open \"%s\".\n", Next);
  188.   else
  189.     next+=1;
  190.     fprintf(outFile,"%d\n",next);
  191.   fclose(outFile);
  192. }
  193.  
  194. /*******************************************************************
  195.  * find_next_entry
  196.  *
  197.  * Takes as arguments an integer, and a file already opened for 
  198.  * input.  It then searches for occurances of a double \n, or the
  199.  * end of the file.  If it finds the occurance "next" of a double \n,
  200.  * it leaves the file pointer there (the beginning of the next 
  201.  * archive entry) and exits.  If it hits the EOF before the "next"
  202.  * occurance of a double \n is found, it returns 1. (So the first 
  203.  * entry in the archive will be read.)
  204.  *******************************************************************/
  205. void find_next_entry(int *next, FILE *inFile)
  206. {
  207.   int localnext=*next;
  208.   char previous,current;
  209.  
  210.   if (localnext!=1) {
  211.     previous=getc(inFile);
  212.     while(localnext>1) {
  213.       current=getc(inFile);
  214.       if ((current=='\n') && (previous=='\n')) localnext-=1;
  215.       if (current==EOF) {
  216.         fseek(inFile,0L,0);
  217.         localnext=1;
  218.         *next=1;
  219.       }
  220.       previous=current;
  221.     }
  222.   }
  223. }
  224.  
  225. /*******************************************************************
  226.  * write_sig
  227.  * 
  228.  * First opens the file DEST for output.
  229.  * Then calls copy_file to copy the contents of PREFIX into DEST, if
  230.  * PREFIX exists.
  231.  * Next it copies from the SOURCE file and appends to DEST until
  232.  * it finds a double \n or the EOF in SOURCE.
  233.  * Finally, if SUFFIX exists, it calls copy_file to copy the contents of 
  234.  * SUFFIX and append it to DEST.
  235.  *******************************************************************/
  236. void write_sig(FILE *inFile)
  237. {
  238.   FILE *outFile;
  239.   int test=0;
  240.   char previous,current;
  241.  
  242.   outFile=fopen(Dest,"w");
  243.   if (outFile==NULL)
  244.     fprintf(stderr,"ERROR: Couldn't open \"%s\".\n", Dest);
  245.   else {
  246.     copy_file(Prefix,outFile);
  247.     previous=fgetc(inFile);
  248.     if (previous==EOF) test=1;
  249.     while(test!=1) {
  250.       current=fgetc(inFile);
  251.       if ((current==EOF) || ((current=='\n') && (previous=='\n')))
  252.         test=1;
  253.       fputc(previous, outFile);
  254.       previous=current;
  255.     }
  256.     copy_file(Suffix,outFile);
  257.     fclose(outFile);
  258.   }
  259. }
  260.  
  261. /*******************************************************************
  262.  * copy_file
  263.  *
  264.  * Takes as arguments a string which contains the full pathname of a 
  265.  * file, and a file already opened for output.
  266.  * It then opens the file, named in the string, for input.
  267.  * Then it copies the entire contents of the input file and appends 
  268.  * it to the output file.
  269.  *******************************************************************/
  270. void copy_file (char *string,FILE *outFile)
  271. {
  272.   FILE *inFile;
  273.   char tmp=0;
  274.  
  275.   inFile=fopen(string,"r");
  276.   if (inFile!=NULL) {
  277.     while(tmp!=EOF) {
  278.       tmp=fgetc(inFile);
  279.       if (tmp!=EOF) fputc(tmp,outFile);
  280.     }
  281.     fclose(inFile);
  282.   }
  283. }
  284.  
  285. /*************************  Thats all folks!  *************************/
  286.